home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_tasks_detail.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-09-17  |  17.9 KB  |  411 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28. #include "system_headers.h"
  29.  
  30. struct LongFlag taskFlags[] = {
  31.     { TF_PROCTIME,  "TF_PROCTIME", "%00000001" },
  32.     { TF_ETASK,     "TF_ETASK",    "%00001000" },
  33.     { TF_STACKCHK,  "TF_STACKCHK", "%00010000" },
  34.     { TF_EXCEPT,    "TF_EXCEPT",   "%00100000" },
  35.     { TF_SWITCH,    "TF_SWITCH",   "%01000000" },
  36.     { TF_LAUNCH,    "TF_LAUNCH",   "%10000000" },
  37.     { 0,            NULL,          NULL }
  38. };
  39.  
  40. struct LongFlag processFlags[] = {
  41.     { PRF_FREESEGLIST, "PRF_FREESEGLIST", "$00000001" },
  42.     { PRF_FREECURRDIR, "PRF_FREECURRDIR", "$00000002" },
  43.     { PRF_FREECLI,     "PRF_FREECLI",     "$00000004" },
  44.     { PRF_CLOSEINPUT,  "PRF_CLOSEINPUT",  "$00000008" },
  45.     { PRF_CLOSEOUTPUT, "PRF_CLOSEOUTPUT", "$00000010" },
  46.     { PRF_FREEARGS,    "PRF_FREEARGS",    "$00000020" },
  47.     { 0,               NULL,              NULL }
  48. };
  49.  
  50. static __asm __saveds LONG seglist_con2func(register __a2 Object *obj, register __a1 struct NList_ConstructMessage *msg, register __a0 struct Hook *hook)
  51. {
  52.     return AllocListEntry(msg->pool, msg->entry, sizeof(struct SegListEntry));
  53. }
  54.  
  55. MakeHook(seglist_con2hook, seglist_con2func);
  56.  
  57. static __asm __saveds LONG seglist_des2func(register __a2 Object *obj, register __a1 struct NList_DestructMessage *msg, register __a0 struct Hook *hook)
  58. {
  59.     FreeListEntry(msg->pool, &msg->entry);
  60.  
  61.     return 0;
  62. }
  63.  
  64. MakeHook(seglist_des2hook, seglist_des2func);
  65.  
  66. static __asm __saveds LONG seglist_dsp2func(register __a2 Object *obj, register __a1 struct NList_DisplayMessage *msg, register __a0 struct Hook *hook)
  67. {
  68.     struct SegListEntry *sle = (struct SegListEntry *)msg->entry;
  69.  
  70.     if (sle) {
  71.         msg->strings[0] = sle->sle_Lower;
  72.         msg->strings[1] = sle->sle_Upper;
  73.         msg->strings[2] = sle->sle_Size;
  74.     } else {
  75.         msg->strings[0] = "Lower";
  76.         msg->strings[1] = "Upper";
  77.         msg->strings[2] = "Size";
  78.         msg->preparses[0] = MUIX_B;
  79.         msg->preparses[1] = MUIX_B;
  80.         msg->preparses[2] = MUIX_B;
  81.     }
  82.  
  83.     return 0;
  84. }
  85.  
  86. MakeHook(seglist_dsp2hook, seglist_dsp2func);
  87.  
  88. static LONG seglist_cmp2colfunc( struct SegListEntry *sle1,
  89.                                  struct SegListEntry *sle2,
  90.                                  ULONG column )
  91. {
  92.     switch (column) {
  93.         case 0: return stricmp(sle1->sle_Lower, sle2->sle_Lower);
  94.         case 1: return stricmp(sle1->sle_Upper, sle2->sle_Upper);
  95.         case 2: return stricmp(sle1->sle_Size, sle2->sle_Size);
  96.     }
  97. }
  98.  
  99. __asm __saveds LONG seglist_cmp2func(register __a2 Object *obj, register __a1 struct NList_CompareMessage *msg, register __a0 struct Hook *hook)
  100. {
  101.     LONG cmp;
  102.     struct SegListEntry *sle1, *sle2;
  103.     ULONG col1, col2;
  104.  
  105.     sle1 = (struct SegListEntry *)msg->entry1;
  106.     sle2 = (struct SegListEntry *)msg->entry2;
  107.     col1 = msg->sort_type & MUIV_NList_TitleMark_ColMask;
  108.     col2 = msg->sort_type2 & MUIV_NList_TitleMark2_ColMask;
  109.  
  110.     if (msg->sort_type == MUIV_NList_SortType_None) return 0;
  111.  
  112.     if (msg->sort_type & MUIV_NList_TitleMark_TypeMask) {
  113.         cmp = seglist_cmp2colfunc(sle2, sle1, col1);
  114.     } else {
  115.         cmp = seglist_cmp2colfunc(sle1, sle2, col1);
  116.     }
  117.  
  118.     if (cmp != 0 || col1 == col2) return cmp;
  119.  
  120.     if (msg->sort_type2 & MUIV_NList_TitleMark2_TypeMask) {
  121.         cmp = seglist_cmp2colfunc(sle2, sle1, col2);
  122.     } else {
  123.         cmp = seglist_cmp2colfunc(sle1, sle2, col2);
  124.     }
  125.  
  126.     return cmp;
  127. }
  128.  
  129. MakeHook(seglist_cmp2hook, seglist_cmp2func);
  130.  
  131. static void SetDetails( struct IClass *cl,
  132.                         Object *obj,
  133.                         struct TaskEntry *te )
  134. {
  135.     struct TasksDetailWinData *tdwd = INST_DATA(cl, obj);
  136.     struct Task *task = te->te_Addr;
  137.     struct Process *proc = (struct Process *)te->te_Addr;
  138.     UBYTE tcflags[16];
  139.  
  140.     Flags2BinStr(task->tc_Flags, tcflags, sizeof(tcflags));
  141.  
  142.     if (task->tc_Node.ln_Type == NT_PROCESS) {
  143.         APTR add,processmoretext0,processmoretext1a,processmoretext1b,processmoretext2,processmoretext3;
  144.         APTR processmoretext4,processmoretext5,processmoretext6a,processmoretext6b,processmoretext7,seglist;
  145.         LONG *seg;
  146.         struct MinList tmplist;
  147.         struct SegListEntry *sle, *_sle;
  148.  
  149.         Child, add = HGroup,
  150.             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  151.                 Child, MyLabel2("Name:"),
  152.                 Child, MyLabel2("Address:\nIDNestCnt:\nTrapAlloc:\nTrapAble:\nTrapData:\nTrapCode:\nUserData:"),
  153.                 Child, MyLabel2("Flags:"),
  154.                 Child, MyLabel2("Pad:\nGlobVec:\nResult2:\nCOS:\nCLI:\nWindowPtr:"),
  155.                 Child, MyLabel2("\nHunks:\n\n\n\n"),
  156.                 Child, MyVSpace(0),
  157.             End,
  158.             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  159.                 Child, processmoretext0 = MyTextObject(),
  160.                 Child, HGroup,
  161.                     Child, VGroup,
  162.                         Child, HGroup,
  163.                             Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 0,
  164.                                 Child, processmoretext1a = MyTextObject(),
  165.                                 Child, processmoretext1b = MakeButton(""),
  166.                                 Child, processmoretext4 = MyTextObject(),
  167.                             End,
  168.                             Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 60,
  169.                                 Child, MyLabel("State:\nTDNestCnt:\nExceptData:\nExceptCode:\nStackSize:\nSPLower:\nSPUpper:\nSPReg:"),
  170.                                 Child, MyVSpace(0),
  171.                                 Child, MyLabel("SegList:\nTaskNum:\nCurrentDir:\nConsoleTask:\nReturnAddr:\nHomeDir:"),
  172.                             End,
  173.                             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  174.                                 Child, processmoretext2 = MyTextObject2(),
  175.                                 Child, MyVSpace(0),
  176.                                 Child, processmoretext5 = MyTextObject2(),
  177.                             End,
  178.                         End,
  179.                         Child, MyVSpace(2),
  180.                         Child, seglist = MyNListviewObject(MakeID('S','L','L','V'), "BAR,BAR,BAR P=" MUIX_R, &seglist_con2hook, &seglist_des2hook, &seglist_dsp2hook, &seglist_cmp2hook, FALSE),
  181.                     End,
  182.                     Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 60,
  183.                         Child, MyLabel("Pri:\nSigAlloc:\nSigWait:\nSigRecvd:\nSigExcept:\nSwitch():\nLaunch():\nMemEntry:"),
  184.                         Child, MyLabel("Flags:"),
  185.                         Child, MyLabel("StackSize:\nStackBase:\nCIS:\nFileSystemTask:\nPktWait:"),
  186.                         Child, MyLabel("ExitCode:\nExitData:\nArguments:\nLocalVars:\nShellPrivate:\nCES:"),
  187.                     End,
  188.                     Child, VGroup, MUIA_Group_SameWidth, TRUE,
  189.                         Child, processmoretext3 = MyTextObject2(),
  190.                         Child, processmoretext6b = MakeButton(""),
  191.                         Child, processmoretext6a = MyTextObject2(),
  192.                         Child, processmoretext7 = MyTextObject2(),
  193.                     End,
  194.                 End,
  195.             End,
  196.         End;
  197.  
  198.         DoMethod(tdwd->tdwd_MainGroup, MUIM_Group_InitChange);
  199.         DoMethod(tdwd->tdwd_MainGroup, OM_ADDMEMBER, add);
  200.         DoMethod(tdwd->tdwd_MainGroup, MUIM_Group_ExitChange);
  201.  
  202.         DoMethod(processmoretext1b, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, MUIM_TasksDetailWin_TaskFlagsMore);
  203.         DoMethod(processmoretext6b, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, MUIM_TasksDetailWin_ProcessFlagsMore);
  204.  
  205.         set(obj, MUIA_Window_ActiveObject, processmoretext1b);
  206.  
  207.         MySetContents(processmoretext0, "%s", te->te_Name);
  208.         MySetContents(processmoretext1a, MUIX_R " $%08lx\n%lD\n$%04lx\n$%04lx\n $%08lx\n $%08lx\n $%08lx", task, task->tc_IDNestCnt, task->tc_TrapAlloc, task->tc_TrapAble, task->tc_TrapData, task->tc_TrapCode, task->tc_UserData);
  209.         MySetContents(processmoretext1b, MUIX_B "%s", tcflags);
  210.         MySetContents(processmoretext2, MUIX_C "%s\n" MUIX_R "%lD\n$%08lx\n$%08lx\n%lD\n$%08lx\n$%08lx\n$%08lx", GetTaskState((BYTE)task->tc_State, task->tc_SigWait), task->tc_TDNestCnt, task->tc_ExceptData, task->tc_ExceptCode, (char *)task->tc_SPUpper - (char *)task->tc_SPLower, task->tc_SPLower, task->tc_SPUpper, task->tc_SPReg);
  211.         MySetContents(processmoretext3, MUIX_R "%ld\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx", task->tc_Node.ln_Pri, task->tc_SigAlloc, task->tc_SigWait, task->tc_SigRecvd, task->tc_SigExcept, task->tc_Switch, task->tc_Launch, task->tc_MemEntry);
  212.         MySetContents(processmoretext4, MUIX_R "$%04lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx", proc->pr_Pad, proc->pr_GlobVec, proc->pr_Result2, BADDR(proc->pr_COS), BADDR(proc->pr_CLI), proc->pr_WindowPtr);
  213.         MySetContents(processmoretext5, MUIX_R "$%08lx\n%s\n$%08lx\n$%08lx\n$%08lx\n$%08lx", BADDR(proc->pr_SegList), te->te_Num, BADDR(proc->pr_CurrentDir), proc->pr_ConsoleTask, proc->pr_ReturnAddr, BADDR(proc->pr_HomeDir));
  214.         MySetContents(processmoretext6a, MUIX_R "%lD\n$%08lx\n$%08lx\n$%08lx\n$%08lx", proc->pr_StackSize, BADDR(proc->pr_StackBase), BADDR(proc->pr_CIS), proc->pr_FileSystemTask, proc->pr_PktWait);
  215.         MySetContents(processmoretext6b, MUIX_B "$%08lx", proc->pr_Flags);
  216.         MySetContents(processmoretext7, MUIX_R "$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx", proc->pr_ExitCode, proc->pr_ExitData, proc->pr_Arguments, proc->pr_LocalVars, proc->pr_ShellPrivate, BADDR(proc->pr_CES));
  217.  
  218.         NewList((struct List *)&tmplist);
  219.  
  220.         ApplicationSleep(TRUE);
  221.  
  222.         set(seglist, MUIA_NList_Quiet, TRUE);
  223.         DoMethod(seglist, MUIM_NList_Clear);
  224.  
  225.         Forbid();
  226.  
  227.         seg = (LONG *)BADDR((LONG) *((LONG *) (((LONG)BADDR(proc->pr_SegList) + 12))));
  228.         if (!points2ram((APTR)seg)) {
  229.             if (proc->pr_CLI != (BPTR)NULL) {
  230.                 seg = (LONG *)BADDR(((struct CommandLineInterface *)BADDR(proc->pr_CLI))->cli_Module);
  231.             }
  232.         }
  233.         if (seg) {
  234.  
  235.             while (seg) {
  236.                 if (sle = AllocVec(sizeof(struct SegListEntry), MEMF_PUBLIC)) {
  237.                     ULONG size;
  238.  
  239.                     size = *(seg - 1);
  240.                     _snprintf(sle->sle_Lower, sizeof(sle->sle_Lower), "$%08lx", (ULONG)seg + 4);
  241.                     _snprintf(sle->sle_Upper, sizeof(sle->sle_Upper), "$%08lx", (ULONG)seg + size - 4);
  242.                     _snprintf(sle->sle_Size, sizeof(sle->sle_Size), "%12lD", size);
  243.  
  244.                     AddTail((struct List *)&tmplist, (struct Node *)sle);
  245.                 }
  246.  
  247.                 seg = (LONG *)BADDR(*seg);
  248.             }
  249.         }
  250.  
  251.         Permit();
  252.  
  253.         ITERATE_CHANGING_LIST(&tmplist, struct SegListEntry *, sle, _sle) {
  254.             InsertBottomEntry(seglist, sle);
  255.             FreeVec(sle);
  256.         }
  257.  
  258.         set(seglist, MUIA_NList_Quiet, FALSE);
  259.  
  260.         ApplicationSleep(FALSE);
  261.  
  262.         set(obj, MUIA_Window_Title, MyGetChildWindowTitle("PROCESS", te->te_Name, tdwd->tdwd_Title, sizeof(tdwd->tdwd_Title)));
  263.     } else {
  264.         APTR add,taskmoretext0,taskmoretext1a,taskmoretext1b,taskmoretext2,taskmoretext3;
  265.  
  266.         Child, add = HGroup,
  267.             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  268.                 Child, MyLabel2 ("Name:"),
  269.                 Child, MyLabel2 ("Address:\nIDNestCnt:\nTrapAlloc:\nTrapAble:\nTrapData:\nTrapCode:\nUserData:"),
  270.                 Child, MyLabel2 ("Flags:"),
  271.             End,
  272.             Child, VGroup, MUIA_Group_SameWidth, TRUE,
  273.                 Child, taskmoretext0 = MyTextObject(),
  274.                 Child, HGroup,
  275.                     Child, VGroup,
  276.                         Child, taskmoretext1a = MyTextObject2(),
  277.                         Child, taskmoretext1b = MakeButton(""),
  278.                     End,
  279.                     Child, MyLabel ("State:\nTDNestCnt:\nExceptData:\nExceptCode:\nStackSize:\nSPLower:\nSPUpper:\nSPReg:"),
  280.                     Child, taskmoretext2 = MyTextObject2(),
  281.                     Child, MyLabel ("Pri:\nSigAlloc:\nSigWait:\nSigRecvd:\nSigExcept:\nSwitch():\nLaunch():\nMemEntry:"),
  282.                     Child, taskmoretext3 = MyTextObject2(),
  283.                 End,
  284.             End,
  285.         End;
  286.  
  287.         DoMethod(tdwd->tdwd_MainGroup, OM_ADDMEMBER, add);
  288.         DoMethod(taskmoretext1b, MUIM_Notify, MUIA_Pressed, FALSE, obj, 1, MUIM_TasksDetailWin_TaskFlagsMore);
  289.  
  290.         set(obj, MUIA_Window_ActiveObject, taskmoretext1b);
  291.  
  292.         MySetContents(taskmoretext0, "%s", te->te_Name);
  293.         MySetContents(taskmoretext1a, MUIX_R " $%08lx\n%lD\n$%04lx\n$%04lx\n $%08lx\n $%08lx\n $%08lx", task, task->tc_IDNestCnt, task->tc_TrapAlloc, task->tc_TrapAble, task->tc_TrapData, task->tc_TrapCode, task->tc_UserData);
  294.         MySetContents(taskmoretext1b, MUIX_B "%s", tcflags);
  295.         MySetContents(taskmoretext2, MUIX_C "%s\n" MUIX_R "%lD\n$%08lx\n$%08lx\n%lD\n$%08lx\n$%08lx\n$%08lx", GetTaskState((BYTE)task->tc_State, task->tc_SigWait), task->tc_TDNestCnt, task->tc_ExceptData, task->tc_ExceptCode, (char *)task->tc_SPUpper - (char *)task->tc_SPLower, task->tc_SPLower, task->tc_SPUpper, task->tc_SPReg);
  296.         MySetContents(taskmoretext3, MUIX_R "%ld\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx\n$%08lx", task->tc_Node.ln_Pri, task->tc_SigAlloc, task->tc_SigWait, task->tc_SigRecvd, task->tc_SigExcept, task->tc_Switch, task->tc_Launch, task->tc_MemEntry);
  297.  
  298.         set(obj, MUIA_Window_Title, MyGetChildWindowTitle("TASK", te->te_Name, tdwd->tdwd_Title, sizeof(tdwd->tdwd_Title)));
  299.     }
  300. }
  301.  
  302. static ULONG __saveds mNew( struct IClass *cl,
  303.                             Object *obj,
  304.                             struct opSet *msg )
  305. {
  306.     APTR taskmoregroup;
  307.  
  308.     if (obj = (Object *)DoSuperNew(cl, obj,
  309.         MUIA_HelpNode, TasksText,
  310.         MUIA_Window_ID, MakeID('.','T','A','S'),
  311.         WindowContents, taskmoregroup = HGroup,
  312.  
  313.         End,
  314.         TAG_MORE, msg->ops_AttrList))
  315.     {
  316.         struct TasksDetailWinData *tdwd = INST_DATA(cl, obj);
  317.         APTR parent;
  318.  
  319.         tdwd->tdwd_MainGroup = taskmoregroup;
  320.  
  321.         parent = (APTR)GetTagData(MUIA_Window_ParentWindow, (ULONG)NULL, msg->ops_AttrList);
  322.  
  323.         DoMethod(parent, MUIM_Window_AddChildWindow, obj);
  324.         DoMethod(obj,    MUIM_Notify,              MUIA_Window_CloseRequest, TRUE,           MUIV_Notify_Application, 5, MUIM_Application_PushMethod, parent, 2, MUIM_Window_RemChildWindow, obj);
  325.     }
  326.  
  327.     return (ULONG)obj;
  328. }
  329.  
  330. static ULONG __saveds mDispose( struct IClass *cl,
  331.                                 Object *obj,
  332.                                 struct opSet *msg )
  333. {
  334.     set(obj, MUIA_Window_Open, FALSE);
  335.  
  336.     return (DoSuperMethodA(cl, obj, msg));
  337. }
  338.  
  339. static ULONG __saveds mSet( struct IClass *cl,
  340.                             Object *obj,
  341.                             Msg msg )
  342. {
  343.     struct TasksDetailWinData *tdwd = INST_DATA(cl, obj);
  344.     struct TagItem *tags, *tag;
  345.  
  346.     for (tags = ((struct opSet *)msg)->ops_AttrList; tag = NextTagItem(&tags); ) {
  347.         switch (tag->ti_Tag) {
  348.             case MUIA_Window_ParentWindow:
  349.                 DoMethod(obj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIV_Notify_Application, 5, MUIM_Application_PushMethod, (APTR)tag->ti_Data, 2, MUIM_Window_RemChildWindow, obj);
  350.                 break;
  351.  
  352.             case MUIA_TasksDetailWin_Task:
  353.                 tdwd->tdwd_Task = (struct TaskEntry *)tag->ti_Data;
  354.                 SetDetails(cl, obj, (struct TaskEntry *)tag->ti_Data);
  355.                 break;
  356.         }
  357.     }
  358.  
  359.     return (DoSuperMethodA(cl,obj,msg));
  360. }
  361.  
  362. static ULONG __saveds mTaskFlagsMore( struct IClass *cl,
  363.                                       Object *obj,
  364.                                       Msg msg )
  365. {
  366.     struct TasksDetailWinData *tdwd = INST_DATA(cl, obj);
  367.     APTR flagsWin;
  368.  
  369.     if (flagsWin = FlagsWindowObject,
  370.             MUIA_Window_Title, "Task Flags",
  371.             MUIA_Window_ParentWindow, obj,
  372.         End) {
  373.         DoMethod(flagsWin, MUIM_FlagsWin_ShowFlags, tdwd->tdwd_Task->te_Addr->tc_Flags, MUIV_FlagsWin_FlagsType_Byte, taskFlags, NULL, "tc_Flags");
  374.     }
  375.  
  376.     return 0;
  377. }
  378.  
  379. static ULONG __saveds mProcessFlagsMore( struct IClass *cl,
  380.                                          Object *obj,
  381.                                          Msg msg )
  382. {
  383.     struct TasksDetailWinData *tdwd = INST_DATA(cl, obj);
  384.     APTR flagsWin;
  385.  
  386.     if (flagsWin = FlagsWindowObject,
  387.             MUIA_Window_Title, "Process Flags",
  388.             MUIA_Window_ParentWindow, obj,
  389.         End) {
  390.         DoMethod(flagsWin, MUIM_FlagsWin_ShowFlags, ((struct Process *)tdwd->tdwd_Task->te_Addr)->pr_Flags, MUIV_FlagsWin_FlagsType_Long, processFlags, NULL, "pr_Flags");
  391.     }
  392.  
  393.     return 0;
  394. }
  395.  
  396. ULONG __asm __saveds TasksDetailWinDispatcher( register __a0 struct IClass *cl,
  397.                                                  register __a2 Object *obj,
  398.                                                  register __a1 Msg msg )
  399. {
  400.     switch (msg->MethodID) {
  401.         case OM_NEW:                               return (mNew(cl, obj, (APTR)msg));
  402.         case OM_DISPOSE:                           return (mDispose(cl, obj, (APTR)msg));
  403.         case OM_SET:                               return (mSet(cl, obj, (APTR)msg));
  404.         case MUIM_TasksDetailWin_TaskFlagsMore:    return (mTaskFlagsMore(cl, obj, (APTR)msg));
  405.         case MUIM_TasksDetailWin_ProcessFlagsMore: return (mProcessFlagsMore(cl, obj, (APTR)msg));
  406.     }
  407.  
  408.     return (DoSuperMethodA(cl, obj, msg));
  409. }
  410.  
  411.